home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / preloaders / DownloadProgressBar.as next >
Text File  |  2014-03-27  |  27KB  |  814 lines
  1. package mx.preloaders
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.GradientType;
  5.    import flash.display.Graphics;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.display.Sprite;
  9.    import flash.events.Event;
  10.    import flash.events.IOErrorEvent;
  11.    import flash.events.ProgressEvent;
  12.    import flash.events.TimerEvent;
  13.    import flash.geom.Matrix;
  14.    import flash.geom.Rectangle;
  15.    import flash.net.URLRequest;
  16.    import flash.system.ApplicationDomain;
  17.    import flash.system.LoaderContext;
  18.    import flash.text.TextField;
  19.    import flash.text.TextFormat;
  20.    import flash.utils.Timer;
  21.    import flash.utils.getDefinitionByName;
  22.    import flash.utils.getTimer;
  23.    import mx.core.mx_internal;
  24.    import mx.events.FlexEvent;
  25.    import mx.events.RSLEvent;
  26.    import mx.graphics.RectangularDropShadow;
  27.    import mx.graphics.RoundedRectangle;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class DownloadProgressBar extends Sprite implements IPreloaderDisplay
  32.    {
  33.       
  34.       mx_internal static const VERSION:String = "3.0.0.0";
  35.       
  36.       private static var _initializingLabel:String = "Initializing";
  37.        
  38.       
  39.       protected var MINIMUM_DISPLAY_TIME:uint = 0;
  40.       
  41.       private var _barFrameRect:RoundedRectangle;
  42.       
  43.       private var _stageHeight:Number = 375;
  44.       
  45.       private var _stageWidth:Number = 500;
  46.       
  47.       private var _percentRect:Rectangle;
  48.       
  49.       private var _percentObj:TextField;
  50.       
  51.       private var _downloadingLabel:String = "Loading";
  52.       
  53.       private var _showProgressBar:Boolean = true;
  54.       
  55.       private var _yOffset:Number = 20;
  56.       
  57.       private var _initProgressCount:uint = 0;
  58.       
  59.       private var _barSprite:Sprite;
  60.       
  61.       private var _visible:Boolean = false;
  62.       
  63.       private var _barRect:RoundedRectangle;
  64.       
  65.       private var _showingDisplay:Boolean = false;
  66.       
  67.       private var _backgroundSize:String = "";
  68.       
  69.       private var _initProgressTotal:uint = 12;
  70.       
  71.       private var _startedInit:Boolean = false;
  72.       
  73.       private var _showLabel:Boolean = true;
  74.       
  75.       private var _value:Number = 0;
  76.       
  77.       private var _labelRect:Rectangle;
  78.       
  79.       private var _backgroundImage:Object;
  80.       
  81.       private var _backgroundAlpha:Number = 1;
  82.       
  83.       private var _backgroundColor:uint;
  84.       
  85.       private var _startedLoading:Boolean = false;
  86.       
  87.       private var _showPercentage:Boolean = false;
  88.       
  89.       private var _barFrameSprite:Sprite;
  90.       
  91.       protected var DOWNLOAD_PERCENTAGE:uint = 60;
  92.       
  93.       private var _displayStartCount:uint = 0;
  94.       
  95.       private var _labelObj:TextField;
  96.       
  97.       private var _borderRect:RoundedRectangle;
  98.       
  99.       private var _maximum:Number = 0;
  100.       
  101.       private var _displayTime:int;
  102.       
  103.       private var _label:String = "";
  104.       
  105.       private var _preloader:Sprite;
  106.       
  107.       private var _xOffset:Number = 20;
  108.       
  109.       private var _startTime:int;
  110.       
  111.       public function DownloadProgressBar()
  112.       {
  113.          _labelRect = labelRect;
  114.          _percentRect = percentRect;
  115.          _borderRect = borderRect;
  116.          _barFrameRect = barFrameRect;
  117.          _barRect = barRect;
  118.          super();
  119.       }
  120.       
  121.       public static function get initializingLabel() : String
  122.       {
  123.          return _initializingLabel;
  124.       }
  125.       
  126.       public static function set initializingLabel(param1:String) : void
  127.       {
  128.          _initializingLabel = param1;
  129.       }
  130.       
  131.       protected function getPercentLoaded(param1:Number, param2:Number) : Number
  132.       {
  133.          var _loc3_:Number = NaN;
  134.          if(param1 == 0 || param2 == 0 || isNaN(param2) || isNaN(param1))
  135.          {
  136.             return 0;
  137.          }
  138.          _loc3_ = 100 * param1 / param2;
  139.          if(isNaN(_loc3_) || _loc3_ <= 0)
  140.          {
  141.             return 0;
  142.          }
  143.          if(_loc3_ > 99)
  144.          {
  145.             return 99;
  146.          }
  147.          return Math.round(_loc3_);
  148.       }
  149.       
  150.       protected function get labelFormat() : TextFormat
  151.       {
  152.          var _loc1_:TextFormat = new TextFormat();
  153.          _loc1_.color = 3355443;
  154.          _loc1_.font = "Verdana";
  155.          _loc1_.size = 10;
  156.          return _loc1_;
  157.       }
  158.       
  159.       private function calcScale() : void
  160.       {
  161.          var _loc1_:Number = NaN;
  162.          if(stageWidth < 160 || stageHeight < 120)
  163.          {
  164.             scaleX = 1;
  165.             scaleY = 1;
  166.          }
  167.          else if(stageWidth < 240 || stageHeight < 150)
  168.          {
  169.             createChildren();
  170.             _loc1_ = Math.min(stageWidth / 240,stageHeight / 150);
  171.             scaleX = _loc1_;
  172.             scaleY = _loc1_;
  173.          }
  174.          else
  175.          {
  176.             createChildren();
  177.          }
  178.       }
  179.       
  180.       protected function get percentRect() : Rectangle
  181.       {
  182.          return new Rectangle(108,4,34,16);
  183.       }
  184.       
  185.       protected function set showLabel(param1:Boolean) : void
  186.       {
  187.          _showLabel = param1;
  188.          draw();
  189.       }
  190.       
  191.       private function calcBackgroundSize() : Number
  192.       {
  193.          var _loc2_:int = 0;
  194.          var _loc1_:Number = NaN;
  195.          if(backgroundSize)
  196.          {
  197.             _loc2_ = backgroundSize.indexOf("%");
  198.             if(_loc2_ != -1)
  199.             {
  200.                _loc1_ = Number(backgroundSize.substr(0,_loc2_));
  201.             }
  202.          }
  203.          return _loc1_;
  204.       }
  205.       
  206.       private function show() : void
  207.       {
  208.          _showingDisplay = true;
  209.          calcScale();
  210.          draw();
  211.          _displayTime = getTimer();
  212.       }
  213.       
  214.       private function loadBackgroundImage(param1:Object) : void
  215.       {
  216.          var cls:Class = null;
  217.          var newStyleObj:DisplayObject = null;
  218.          var loader:Loader = null;
  219.          var loaderContext:LoaderContext = null;
  220.          var classOrString:Object = param1;
  221.          if(classOrString && classOrString as Class)
  222.          {
  223.             cls = Class(classOrString);
  224.             initBackgroundImage(new cls());
  225.          }
  226.          else if(classOrString && classOrString is String)
  227.          {
  228.             try
  229.             {
  230.                cls = Class(getDefinitionByName(String(classOrString)));
  231.             }
  232.             catch(e:Error)
  233.             {
  234.             }
  235.             if(cls)
  236.             {
  237.                newStyleObj = new cls();
  238.                initBackgroundImage(newStyleObj);
  239.             }
  240.             else
  241.             {
  242.                loader = new Loader();
  243.                loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loader_completeHandler);
  244.                loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,loader_ioErrorHandler);
  245.                loaderContext = new LoaderContext();
  246.                loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
  247.                loader.load(new URLRequest(String(classOrString)),loaderContext);
  248.             }
  249.          }
  250.       }
  251.       
  252.       protected function set showPercentage(param1:Boolean) : void
  253.       {
  254.          _showPercentage = param1;
  255.          draw();
  256.       }
  257.       
  258.       protected function get barFrameRect() : RoundedRectangle
  259.       {
  260.          return new RoundedRectangle(14,40,154,4);
  261.       }
  262.       
  263.       private function loader_ioErrorHandler(param1:IOErrorEvent) : void
  264.       {
  265.       }
  266.       
  267.       protected function rslErrorHandler(param1:RSLEvent) : void
  268.       {
  269.          _preloader.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  270.          _preloader.removeEventListener(Event.COMPLETE,completeHandler);
  271.          _preloader.removeEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  272.          _preloader.removeEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  273.          _preloader.removeEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  274.          _preloader.removeEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  275.          _preloader.removeEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  276.          if(!_showingDisplay)
  277.          {
  278.             show();
  279.             _showingDisplay = true;
  280.          }
  281.          label = "RSL Error " + (param1.rslIndex + 1) + " of " + param1.rslTotal;
  282.          var _loc2_:ErrorField = new ErrorField(this.parent);
  283.          _loc2_.show(param1.errorText);
  284.       }
  285.       
  286.       protected function rslCompleteHandler(param1:RSLEvent) : void
  287.       {
  288.          label = "Loaded library " + param1.rslIndex + " of " + param1.rslTotal;
  289.       }
  290.       
  291.       protected function get borderRect() : RoundedRectangle
  292.       {
  293.          return new RoundedRectangle(0,0,182,60,4);
  294.       }
  295.       
  296.       protected function showDisplayForDownloading(param1:int, param2:ProgressEvent) : Boolean
  297.       {
  298.          return param1 > 700 && param2.bytesLoaded < param2.bytesTotal / 2;
  299.       }
  300.       
  301.       protected function createChildren() : void
  302.       {
  303.          var _loc2_:TextField = null;
  304.          var _loc3_:TextField = null;
  305.          var _loc1_:Graphics = graphics;
  306.          if(backgroundColor != 4294967295)
  307.          {
  308.             _loc1_.beginFill(backgroundColor,backgroundAlpha);
  309.             _loc1_.drawRect(0,0,stageWidth,stageHeight);
  310.          }
  311.          if(backgroundImage != null)
  312.          {
  313.             loadBackgroundImage(backgroundImage);
  314.          }
  315.          _barFrameSprite = new Sprite();
  316.          _barSprite = new Sprite();
  317.          addChild(_barFrameSprite);
  318.          addChild(_barSprite);
  319.          _loc1_.beginFill(13421772,0.4);
  320.          _loc1_.drawRoundRect(calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height,_borderRect.cornerRadius * 2,_borderRect.cornerRadius * 2);
  321.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  322.          _loc1_.endFill();
  323.          _loc1_.beginFill(13421772,0.4);
  324.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  325.          _loc1_.endFill();
  326.          var _loc4_:Graphics = _barFrameSprite.graphics;
  327.          var _loc5_:Matrix;
  328.          (_loc5_ = new Matrix()).createGradientBox(_barFrameRect.width,_barFrameRect.height,Math.PI / 2,calcX(_barFrameRect.x),calcY(_barFrameRect.y));
  329.          _loc4_.beginGradientFill(GradientType.LINEAR,[6054502,11909306],[1,1],[0,255],_loc5_);
  330.          _loc4_.drawRoundRect(calcX(_barFrameRect.x),calcY(_barFrameRect.y),_barFrameRect.width,_barFrameRect.height,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  331.          _loc4_.drawRoundRect(calcX(_barFrameRect.x + 1),calcY(_barFrameRect.y + 1),_barFrameRect.width - 2,_barFrameRect.height - 2,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  332.          _loc4_.endFill();
  333.          _labelObj = new TextField();
  334.          _labelObj.x = calcX(_labelRect.x);
  335.          _labelObj.y = calcY(_labelRect.y);
  336.          _labelObj.width = _labelRect.width;
  337.          _labelObj.height = _labelRect.height;
  338.          _labelObj.selectable = false;
  339.          _labelObj.defaultTextFormat = labelFormat;
  340.          addChild(_labelObj);
  341.          _percentObj = new TextField();
  342.          _percentObj.x = calcX(_percentRect.x);
  343.          _percentObj.y = calcY(_percentRect.y);
  344.          _percentObj.width = _percentRect.width;
  345.          _percentObj.height = _percentRect.height;
  346.          _percentObj.selectable = false;
  347.          _percentObj.defaultTextFormat = percentFormat;
  348.          addChild(_percentObj);
  349.          var _loc6_:RectangularDropShadow;
  350.          (_loc6_ = new RectangularDropShadow()).color = 0;
  351.          _loc6_.angle = 90;
  352.          _loc6_.alpha = 0.6;
  353.          _loc6_.distance = 2;
  354.          _loc6_.tlRadius = _loc6_.trRadius = _loc6_.blRadius = _loc6_.brRadius = _borderRect.cornerRadius;
  355.          _loc6_.drawShadow(_loc1_,calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height);
  356.          _loc1_.lineStyle(1,16777215,0.3);
  357.          _loc1_.moveTo(calcX(_borderRect.x) + _borderRect.cornerRadius,calcY(_borderRect.y));
  358.          _loc1_.lineTo(calcX(_borderRect.x) - _borderRect.cornerRadius + _borderRect.width,calcY(_borderRect.y));
  359.       }
  360.       
  361.       private function draw() : void
  362.       {
  363.          var _loc1_:Number = NaN;
  364.          if(_startedLoading)
  365.          {
  366.             if(!_startedInit)
  367.             {
  368.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * DOWNLOAD_PERCENTAGE / 100);
  369.             }
  370.             else
  371.             {
  372.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * (100 - DOWNLOAD_PERCENTAGE) / 100 + DOWNLOAD_PERCENTAGE);
  373.             }
  374.          }
  375.          else
  376.          {
  377.             _loc1_ = getPercentLoaded(_value,_maximum);
  378.          }
  379.          if(_labelObj)
  380.          {
  381.             _labelObj.text = _label;
  382.          }
  383.          if(_percentObj)
  384.          {
  385.             if(!_showPercentage)
  386.             {
  387.                _percentObj.visible = false;
  388.                _percentObj.text = "";
  389.             }
  390.             else
  391.             {
  392.                _percentObj.text = String(_loc1_) + "%";
  393.             }
  394.          }
  395.          if(_barSprite && _barFrameSprite)
  396.          {
  397.             if(!_showProgressBar)
  398.             {
  399.                _barSprite.visible = false;
  400.                _barFrameSprite.visible = false;
  401.             }
  402.             else
  403.             {
  404.                drawProgressBar(_loc1_);
  405.             }
  406.          }
  407.       }
  408.       
  409.       private function timerHandler(param1:Event = null) : void
  410.       {
  411.          dispatchEvent(new Event(Event.COMPLETE));
  412.       }
  413.       
  414.       private function hide() : void
  415.       {
  416.       }
  417.       
  418.       public function get backgroundSize() : String
  419.       {
  420.          return _backgroundSize;
  421.       }
  422.       
  423.       protected function center(param1:Number, param2:Number) : void
  424.       {
  425.          _xOffset = Math.floor((param1 - _borderRect.width) / 2);
  426.          _yOffset = Math.floor((param2 - _borderRect.height) / 2);
  427.       }
  428.       
  429.       protected function progressHandler(param1:ProgressEvent) : void
  430.       {
  431.          var _loc2_:uint = param1.bytesLoaded;
  432.          var _loc3_:uint = param1.bytesTotal;
  433.          var _loc4_:int = getTimer() - _startTime;
  434.          if(_showingDisplay || showDisplayForDownloading(_loc4_,param1))
  435.          {
  436.             if(!_startedLoading)
  437.             {
  438.                show();
  439.                label = downloadingLabel;
  440.                _startedLoading = true;
  441.             }
  442.             setProgress(param1.bytesLoaded,param1.bytesTotal);
  443.          }
  444.       }
  445.       
  446.       protected function initProgressHandler(param1:Event) : void
  447.       {
  448.          var _loc3_:Number = NaN;
  449.          var _loc2_:int = getTimer() - _startTime;
  450.          ++_initProgressCount;
  451.          if(!_showingDisplay && showDisplayForInit(_loc2_,_initProgressCount))
  452.          {
  453.             _displayStartCount = _initProgressCount;
  454.             show();
  455.          }
  456.          else if(_showingDisplay)
  457.          {
  458.             if(!_startedInit)
  459.             {
  460.                _startedInit = true;
  461.                label = initializingLabel;
  462.             }
  463.             _loc3_ = 100 * _initProgressCount / (_initProgressTotal - _displayStartCount);
  464.             setProgress(_loc3_,100);
  465.          }
  466.       }
  467.       
  468.       protected function set downloadingLabel(param1:String) : void
  469.       {
  470.          _downloadingLabel = param1;
  471.       }
  472.       
  473.       public function get stageWidth() : Number
  474.       {
  475.          return _stageWidth;
  476.       }
  477.       
  478.       protected function get showPercentage() : Boolean
  479.       {
  480.          return _showPercentage;
  481.       }
  482.       
  483.       override public function get visible() : Boolean
  484.       {
  485.          return _visible;
  486.       }
  487.       
  488.       public function set stageHeight(param1:Number) : void
  489.       {
  490.          _stageHeight = param1;
  491.       }
  492.       
  493.       public function initialize() : void
  494.       {
  495.          _startTime = getTimer();
  496.          center(stageWidth,stageHeight);
  497.       }
  498.       
  499.       protected function rslProgressHandler(param1:RSLEvent) : void
  500.       {
  501.       }
  502.       
  503.       protected function get barRect() : RoundedRectangle
  504.       {
  505.          return new RoundedRectangle(14,39,154,6,0);
  506.       }
  507.       
  508.       protected function get percentFormat() : TextFormat
  509.       {
  510.          var _loc1_:TextFormat = new TextFormat();
  511.          _loc1_.align = "right";
  512.          _loc1_.color = 0;
  513.          _loc1_.font = "Verdana";
  514.          _loc1_.size = 10;
  515.          return _loc1_;
  516.       }
  517.       
  518.       public function set backgroundImage(param1:Object) : void
  519.       {
  520.          _backgroundImage = param1;
  521.       }
  522.       
  523.       private function calcX(param1:Number) : Number
  524.       {
  525.          return param1 + _xOffset;
  526.       }
  527.       
  528.       private function calcY(param1:Number) : Number
  529.       {
  530.          return param1 + _yOffset;
  531.       }
  532.       
  533.       public function set backgroundAlpha(param1:Number) : void
  534.       {
  535.          _backgroundAlpha = param1;
  536.       }
  537.       
  538.       private function initCompleteHandler(param1:Event) : void
  539.       {
  540.          var _loc3_:Timer = null;
  541.          var _loc2_:int = getTimer() - _displayTime;
  542.          if(_showingDisplay && _loc2_ < MINIMUM_DISPLAY_TIME)
  543.          {
  544.             _loc3_ = new Timer(MINIMUM_DISPLAY_TIME - _loc2_,1);
  545.             _loc3_.addEventListener(TimerEvent.TIMER,timerHandler);
  546.             _loc3_.start();
  547.          }
  548.          else
  549.          {
  550.             timerHandler();
  551.          }
  552.       }
  553.       
  554.       public function set backgroundColor(param1:uint) : void
  555.       {
  556.          _backgroundColor = param1;
  557.       }
  558.       
  559.       private function initBackgroundImage(param1:DisplayObject) : void
  560.       {
  561.          var _loc7_:Number = NaN;
  562.          var _loc8_:Number = NaN;
  563.          var _loc9_:Number = NaN;
  564.          addChildAt(param1,0);
  565.          var _loc2_:Number = param1.width;
  566.          var _loc3_:Number = param1.height;
  567.          var _loc4_:Number = calcBackgroundSize();
  568.          if(isNaN(_loc4_))
  569.          {
  570.             _loc7_ = 1;
  571.             _loc8_ = 1;
  572.          }
  573.          else
  574.          {
  575.             _loc7_ = (_loc9_ = _loc4_ * 0.01) * stageWidth / _loc2_;
  576.             _loc8_ = _loc9_ * stageHeight / _loc3_;
  577.          }
  578.          param1.scaleX = _loc7_;
  579.          param1.scaleY = _loc8_;
  580.          var _loc5_:Number = Math.round(0.5 * (stageWidth - _loc2_ * _loc7_));
  581.          var _loc6_:Number = Math.round(0.5 * (stageHeight - _loc3_ * _loc8_));
  582.          param1.x = _loc5_;
  583.          param1.y = _loc6_;
  584.          if(!isNaN(backgroundAlpha))
  585.          {
  586.             param1.alpha = backgroundAlpha;
  587.          }
  588.       }
  589.       
  590.       public function set backgroundSize(param1:String) : void
  591.       {
  592.          _backgroundSize = param1;
  593.       }
  594.       
  595.       protected function showDisplayForInit(param1:int, param2:int) : Boolean
  596.       {
  597.          return param1 > 300 && param2 == 2;
  598.       }
  599.       
  600.       protected function get downloadingLabel() : String
  601.       {
  602.          return _downloadingLabel;
  603.       }
  604.       
  605.       private function loader_completeHandler(param1:Event) : void
  606.       {
  607.          var _loc2_:DisplayObject = DisplayObject(LoaderInfo(param1.target).loader);
  608.          initBackgroundImage(_loc2_);
  609.       }
  610.       
  611.       protected function setProgress(param1:Number, param2:Number) : void
  612.       {
  613.          if(!isNaN(param1) && !isNaN(param2) && param1 >= 0 && param2 > 0)
  614.          {
  615.             _value = Number(param1);
  616.             _maximum = Number(param2);
  617.             draw();
  618.          }
  619.       }
  620.       
  621.       public function get stageHeight() : Number
  622.       {
  623.          return _stageHeight;
  624.       }
  625.       
  626.       public function get backgroundImage() : Object
  627.       {
  628.          return _backgroundImage;
  629.       }
  630.       
  631.       public function get backgroundAlpha() : Number
  632.       {
  633.          if(!isNaN(_backgroundAlpha))
  634.          {
  635.             return _backgroundAlpha;
  636.          }
  637.          return 1;
  638.       }
  639.       
  640.       private function drawProgressBar(param1:Number) : void
  641.       {
  642.          var _loc11_:Number = NaN;
  643.          var _loc2_:Graphics = _barSprite.graphics;
  644.          _loc2_.clear();
  645.          var _loc3_:Array = [16777215,16777215];
  646.          var _loc4_:Array = [0,255];
  647.          var _loc5_:Matrix = new Matrix();
  648.          var _loc6_:Number;
  649.          var _loc7_:Number = (_loc6_ = _barRect.width * param1 / 100) / 2;
  650.          var _loc8_:Number = _barRect.height - 4;
  651.          var _loc9_:Number = calcX(_barRect.x);
  652.          var _loc10_:Number = calcY(_barRect.y) + 2;
  653.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  654.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.39,0.85],_loc4_,_loc5_);
  655.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,_loc8_);
  656.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  657.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.85,1],_loc4_,_loc5_);
  658.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,_loc8_);
  659.          _loc7_ = _loc6_ / 3;
  660.          _loc8_ = _barRect.height;
  661.          _loc11_ = (_loc10_ = calcY(_barRect.y)) + _loc8_ - 1;
  662.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  663.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.05,0.15],_loc4_,_loc5_);
  664.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  665.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  666.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  667.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.25],_loc4_,_loc5_);
  668.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  669.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  670.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  671.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.25,0.1],_loc4_,_loc5_);
  672.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  673.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  674.          _loc7_ = _loc6_ / 3;
  675.          _loc8_ = _barRect.height;
  676.          _loc10_ = calcY(_barRect.y) + 1;
  677.          _loc11_ = calcY(_barRect.y) + _loc8_ - 2;
  678.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  679.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.3],_loc4_,_loc5_);
  680.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  681.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  682.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  683.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.3,0.4],_loc4_,_loc5_);
  684.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  685.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  686.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  687.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.4,0.25],_loc4_,_loc5_);
  688.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  689.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  690.       }
  691.       
  692.       public function get backgroundColor() : uint
  693.       {
  694.          return _backgroundColor;
  695.       }
  696.       
  697.       public function set stageWidth(param1:Number) : void
  698.       {
  699.          _stageWidth = param1;
  700.       }
  701.       
  702.       protected function completeHandler(param1:Event) : void
  703.       {
  704.       }
  705.       
  706.       protected function set label(param1:String) : void
  707.       {
  708.          if(!(param1 is Function))
  709.          {
  710.             _label = param1;
  711.          }
  712.          draw();
  713.       }
  714.       
  715.       public function set preloader(param1:Sprite) : void
  716.       {
  717.          _preloader = param1;
  718.          param1.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  719.          param1.addEventListener(Event.COMPLETE,completeHandler);
  720.          param1.addEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  721.          param1.addEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  722.          param1.addEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  723.          param1.addEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  724.          param1.addEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  725.       }
  726.       
  727.       protected function get label() : String
  728.       {
  729.          return _label;
  730.       }
  731.       
  732.       protected function get labelRect() : Rectangle
  733.       {
  734.          return new Rectangle(14,17,100,16);
  735.       }
  736.       
  737.       override public function set visible(param1:Boolean) : void
  738.       {
  739.          if(!_visible && param1)
  740.          {
  741.             show();
  742.          }
  743.          else if(_visible && !param1)
  744.          {
  745.             hide();
  746.          }
  747.          _visible = param1;
  748.       }
  749.       
  750.       protected function get showLabel() : Boolean
  751.       {
  752.          return _showLabel;
  753.       }
  754.    }
  755. }
  756.  
  757. import flash.display.DisplayObjectContainer;
  758. import flash.display.Sprite;
  759. import flash.display.Stage;
  760. import flash.system.Capabilities;
  761. import flash.text.TextField;
  762. import flash.text.TextFieldAutoSize;
  763. import flash.text.TextFormat;
  764.  
  765. class ErrorField extends Sprite
  766. {
  767.     
  768.    
  769.    private const TEXT_MARGIN_PX:int = 10;
  770.    
  771.    private var parentContainer:DisplayObjectContainer;
  772.    
  773.    private const MAX_WIDTH_INCHES:int = 6;
  774.    
  775.    private const MIN_WIDTH_INCHES:int = 2;
  776.    
  777.    function ErrorField(param1:DisplayObjectContainer)
  778.    {
  779.       super();
  780.       this.parentContainer = param1;
  781.    }
  782.    
  783.    public function show(param1:String) : void
  784.    {
  785.       if(param1 == null || param1.length == 0)
  786.       {
  787.          return;
  788.       }
  789.       var _loc2_:Stage = parentContainer.stage;
  790.       var _loc3_:TextField = new TextField();
  791.       _loc3_.autoSize = TextFieldAutoSize.LEFT;
  792.       _loc3_.multiline = true;
  793.       _loc3_.wordWrap = true;
  794.       _loc3_.background = true;
  795.       _loc3_.defaultTextFormat = labelFormat;
  796.       _loc3_.text = param1;
  797.       _loc3_.width = Math.max(MIN_WIDTH_INCHES * Capabilities.screenDPI,_loc2_.stageWidth - TEXT_MARGIN_PX * 2);
  798.       _loc3_.width = Math.min(MAX_WIDTH_INCHES * Capabilities.screenDPI,_loc3_.width);
  799.       _loc3_.y = Math.max(0,_loc2_.stageHeight - TEXT_MARGIN_PX - _loc3_.height);
  800.       _loc3_.x = (_loc2_.stageWidth - _loc3_.width) / 2;
  801.       parentContainer.addChild(this);
  802.       this.addChild(_loc3_);
  803.    }
  804.    
  805.    protected function get labelFormat() : TextFormat
  806.    {
  807.       var _loc1_:TextFormat = new TextFormat();
  808.       _loc1_.color = 0;
  809.       _loc1_.font = "Verdana";
  810.       _loc1_.size = 10;
  811.       return _loc1_;
  812.    }
  813. }
  814.